home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / TUTORC.ZIP / TUTSUBS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-30  |  20.2 KB  |  792 lines
  1. /* 
  2.   tutsubs.c
  3.   10/30/94
  4.   from gfx2.pas
  5.   Adapted from Denthor's gfx2.pas
  6.   Translated into C, from Denthor's VGA Trainer, by
  7.   Steve Pinault, scp@ohm.att.com
  8.   Compiled with Microsoft Visual C++ 1.5 (Microsoft C 8.0)
  9.   To compile:
  10.   First compile the subroutines in tutsubs.c with the batch file 
  11.   cltutsub.bat
  12.   Then compile any of the tutor programs with the batch file
  13.   cltut.bat
  14.   Example: C:>cltutsub
  15.            C:>cltut tut2.c
  16. */
  17.  
  18. #include <stdio.h>
  19. #include <stdlib.h>
  20. #include <dos.h>
  21. #include <math.h>
  22. #include <conio.h>
  23. #include <graph.h>
  24. #include <bios.h>
  25. #include <string.h> 
  26. #include <time.h> 
  27. #include "tutheadr.h"
  28.  
  29.  
  30. //DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  31. //Procedure SetMCGA;  { This procedure gets you into 320x200x256 mode. }
  32. void SetMCGA()
  33. {
  34.   _asm
  35.   {
  36.      mov        ax,0013h
  37.      int        10h
  38.   }
  39. }
  40.  
  41.  
  42. //DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  43. //Procedure SetText;  { This procedure returns you to text mode.  }
  44. void SetText()
  45. {
  46.   _asm
  47.   {
  48.      mov        ax,0003h
  49.      int        10h
  50.   }
  51. }
  52.  
  53.  
  54. //{DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  55. //procedure WaitRetrace; assembler;
  56. /*
  57.     This waits until you are in a Verticle Retrace ... this means that all
  58.     screen manipulation you do only appears on screen in the next verticle
  59.     retrace ... this removes most of the "fuzz" that you see on the screen
  60.     when changing the pallette. It unfortunately slows down your program
  61.     by "synching" your program with your monitor card ... it does mean
  62.     that the program will run at almost the same speed on different
  63.     speeds of computers which have similar monitors. In our SilkyDemo,
  64.     we used a WaitRetrace, and it therefore runs at the same (fairly
  65.     fast) speed when Turbo is on or off. 
  66. */
  67.  
  68. void WaitRetrace()
  69. {
  70.   _asm
  71.   {
  72.     mov dx,3DAh
  73. l1:
  74.     in al,dx
  75.     and al,08h
  76.     jnz l1
  77. l2:
  78.     in al,dx
  79.     and al,08h
  80.     jz  l2
  81.   }
  82. }
  83.  
  84.  
  85. //DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  86. //Procedure GetPal(ColorNo : Byte; Var R,G,B : Byte);
  87. void GetPal(char ColorNo, char* R, char* G, char* B)
  88. //  This reads the values of the Red, Green and Blue values of a certain
  89. //  color and returns them to you. 
  90. {
  91.    outp(0x3c7,ColorNo);
  92.    *R=inp(0x3c9);
  93.    *G=inp(0x3c9);
  94.    *B=inp(0x3c9);
  95. }
  96.  
  97.  
  98. //DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  99. //Procedure Pal(ColorNo : Byte; R,G,B : Byte);
  100. void Pal(char ColorNo, char R, char G, char B)
  101. //  This sets the Red, Green and Blue values of a certain color 
  102. {
  103.    outp(0x3c8,ColorNo);
  104.    outp(0x3c9,R);
  105.    outp(0x3c9,G);
  106.    outp(0x3c9,B);
  107. }
  108.  
  109. //////////////////////////////////////////////////////////////
  110. void SetAllPal(char far* pal)
  111. { 
  112.   outp(0x3c8,0x0); // Set to first color
  113.   _asm
  114.   {
  115.     mov  cx,768
  116.     lds  si,pal   // loads pal into ds:si
  117.     mov  dx,0x3c9  
  118.     rep  outsb    // sends out the string pointed to by ds:si
  119.   }
  120. }
  121.  
  122. //DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  123. //Procedure PutPixel (X,Y : Integer; Col : Byte);
  124. //  This puts a pixel on the screen by writing directly to memory. 
  125. void PutPixel(int X, int Y, char Color, int Where)
  126. {
  127.   unsigned char far* VGAScreenPtr;
  128.   unsigned int offset;
  129.   offset=(unsigned)X + (unsigned)(Y<<8) + (unsigned)(Y<<6);
  130.   VGAScreenPtr=MK_FP(Where,offset);
  131.   *VGAScreenPtr=Color;
  132. }
  133.  
  134. ////////////////////////// line //////////////////////////////////
  135. //  Procedure line(a,b,c,d,col:integer);
  136. //  This draws a line from a,b to c,d of color col. }
  137. //  This routine is adapted from Programmer's Guide to the EGA and VGA Cards,
  138. //  by Ferraro. It's Bresenham's algorithm. I used it instead of translating
  139. //  the one in the trainer because I already had it and it worked.
  140.  
  141. void Line(int x1, int y1, int x2, int y2, unsigned char Color)
  142.  
  143. {
  144.   int dx,dy,incr1,incr2,d,x,y,xend,yend,yinc,xinc;
  145.  
  146.   dx=abs(x2-x1);
  147.   dy=abs(y2-y1);
  148.  
  149.   if(dx>=dy) // slope < 1
  150.   {
  151.     if(x1>x2)
  152.     {
  153.       x=x2; y=y2; xend=x1;
  154.       if(dy==0) yinc=0;
  155.       else { if(y2>y1) yinc=-1; else yinc=1;}
  156.     }
  157.     else
  158.     {
  159.       x=x1; y=y1; xend=x2;
  160.       if(dy==0) yinc=0;
  161.       else { if(y2>y1) yinc=1; else yinc=-1;}
  162.     }
  163.     incr1=2*dy; d=incr1-dx; incr2=2*(dy-dx);
  164.     PutPixel(x,y,Color,VGA);
  165.     while(x<xend)
  166.     {
  167.       x++;
  168.       if(d<0) d+=incr1;
  169.       else { y+=yinc; d+=incr2;}
  170.       PutPixel(x,y,Color,VGA);
  171.     }
  172.   }
  173.   else
  174.   {
  175.     if(y1>y2)
  176.     { 
  177.       x=x2; y=y2; yend=y1;
  178.       if(dx==0) xinc=0;
  179.       else { if(x2>x1) xinc = -1; else xinc = 1;}
  180.     }
  181.     else
  182.     {
  183.       x=x1; y=y1; yend=y2;
  184.       if(dx==0) xinc=0;
  185.       else { if(x2>x1) xinc=1; else xinc = -1;}
  186.     }
  187.     incr1=2*dx; d=incr1-dy; incr2=2*(dx-dy);
  188.     PutPixel(x,y,Color,VGA);
  189.     while(y<yend)
  190.     {
  191.       y++;
  192.       if(d<0) d+=incr1;
  193.       else { x+=xinc; d+=incr2; }
  194.       PutPixel(x,y,Color,VGA);
  195.     }
  196.   }
  197. }
  198. //////////////////////////////////////////////////////////////////
  199.  
  200. void Line2(int x1, int y1, int x2, int y2, unsigned char Color, int where)
  201. // Same as Line (above), except takes the argument where instead of
  202. // being hard coded to write to VGA.
  203.  
  204. //////////////////////////////////////////////////////////////////
  205. {
  206.   int dx,dy,incr1,incr2,d,x,y,xend,yend,yinc,xinc;
  207.  
  208.   dx=abs(x2-x1);
  209.   dy=abs(y2-y1);
  210.  
  211.   if(dx>=dy) // slope < 1
  212.   {
  213.     if(x1>x2)
  214.     {
  215.       x=x2; y=y2; xend=x1;
  216.       if(dy==0) yinc=0;
  217.       else { if(y2>y1) yinc=-1; else yinc=1;}
  218.     }
  219.     else
  220.     {
  221.       x=x1; y=y1; xend=x2;
  222.       if(dy==0) yinc=0;
  223.       else { if(y2>y1) yinc=1; else yinc=-1;}
  224.     }
  225.     incr1=2*dy; d=incr1-dx; incr2=2*(dy-dx);
  226.     PutPixel(x,y,Color,where);
  227.     while(x<xend)
  228.     {
  229.       x++;
  230.       if(d<0) d+=incr1;
  231.       else { y+=yinc; d+=incr2;}
  232.       PutPixel(x,y,Color,where);
  233.     }
  234.   }
  235.   else
  236.   {
  237.     if(y1>y2)
  238.     { 
  239.       x=x2; y=y2; yend=y1;
  240.       if(dx==0) xinc=0;
  241.       else { if(x2>x1) xinc = -1; else xinc = 1;}
  242.     }
  243.     else
  244.     {
  245.       x=x1; y=y1; yend=y2;
  246.       if(dx==0) xinc=0;
  247.       else { if(x2>x1) xinc=1; else xinc = -1;}
  248.     }
  249.     incr1=2*dx; d=incr1-dy; incr2=2*(dx-dy);
  250.     PutPixel(x,y,Color,where);
  251.     while(y<yend)
  252.     {
  253.       y++;
  254.       if(d<0) d+=incr1;
  255.       else { x+=xinc; d+=incr2; }
  256.       PutPixel(x,y,Color,where);
  257.     }
  258.   }
  259. }
  260.  
  261.  
  262. ////////////////////////// Funny_Line //////////////////////////////////
  263.  
  264. void Funny_Line(int x1, int y1, int x2, int y2, int where)
  265.  
  266. //////////////////////////////////////////////////////////////////
  267. {
  268.   int dx,dy,incr1,incr2,d,x,y,xend,yend,yinc,xinc;
  269.   int count = 50;
  270.  
  271.   dx=abs(x2-x1);
  272.   dy=abs(y2-y1);
  273.  
  274.   if(dx>=dy) // slope < 1
  275.   {
  276.     if(x1>x2)
  277.     {
  278.       x=x2; y=y2; xend=x1;
  279.       if(dy==0) yinc=0;
  280.       else { if(y2>y1) yinc=-1; else yinc=1;}
  281.     }
  282.     else
  283.     {
  284.       x=x1; y=y1; xend=x2;
  285.       if(dy==0) yinc=0;
  286.       else { if(y2>y1) yinc=1; else yinc=-1;}
  287.     }
  288.     incr1=2*dy; d=incr1-dx; incr2=2*(dy-dx);
  289.     PutPixel(x,y,(char)count,where);
  290.     count++;
  291.     if(count==101)count=50;
  292.     while(x<xend)
  293.     {
  294.       x++;
  295.       if(d<0) d+=incr1;
  296.       else { y+=yinc; d+=incr2;}
  297.       PutPixel(x,y,(char)count,where);
  298.       count++;
  299.       if(count==101)count=50;
  300.     }
  301.   }
  302.   else
  303.   {
  304.     if(y1>y2)
  305.     { 
  306.       x=x2; y=y2; yend=y1;
  307.       if(dx==0) xinc=0;
  308.       else { if(x2>x1) xinc = -1; else xinc = 1;}
  309.     }
  310.     else
  311.     {
  312.       x=x1; y=y1; yend=y2;
  313.       if(dx==0) xinc=0;
  314.       else { if(x2>x1) xinc=1; else xinc = -1;}
  315.     }
  316.     incr1=2*dx; d=incr1-dy; incr2=2*(dx-dy);
  317.     PutPixel(x,y,(char)count,where);
  318.     count++;
  319.     if(count==101)count=50;
  320.     while(y<yend)
  321.     {
  322.       y++;
  323.       if(d<0) d+=incr1;
  324.       else { x+=xinc; d+=incr2; }
  325.       PutPixel(x,y,(char)count,where);
  326.       count++;
  327.       if(count==101)count=50;
  328.     }
  329.   }
  330. }
  331. // {DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  332. // Procedure PalPlay;
  333. void PalPlay()
  334. {
  335. //  This procedure mucks about with our "virtual pallette", then shoves it
  336. //  to screen. 
  337. //  This is used as a "temporary color" in our pallette:
  338.     char Tmp[3];
  339.  
  340. // This copies color 200 from our virtual pallette to the Tmp variable:
  341.    _fmemmove(Tmp,Pall[200],3);
  342. // This moves the entire virtual pallette up one color:
  343.    _fmemmove(Pall[2],Pall[1],199*3);
  344. // This copies the Tmp variable to the bottom of the virtual pallette:
  345. // Don't change 0: leave this always black to not change overscan color.
  346.    _fmemmove(Pall[1],Tmp,3);
  347.    WaitRetrace();
  348.    SetAllPal((char far*)&Pall[0][0]);
  349. }
  350.  
  351. //////////////////////////////////////////////////////////////////////
  352. // More general purpose version of the above routine, used in tut7.c:
  353. // Moves all colors up one. Note fmemmove is (dest,src)
  354.  
  355. void rotatepal(char locpal[][3], int start, int end)
  356. {
  357.    char Tmp[3];
  358.    int loop1;
  359.    int number=end-start;
  360.  
  361.    _fmemmove(Tmp,locpal[end],3);
  362.    _fmemmove(locpal[start+1],locpal[start],number*3);
  363.    _fmemmove(locpal[start],Tmp,3);
  364.    WaitRetrace();
  365.    for(loop1=start;loop1<end+1;loop1++)
  366.      Pal((unsigned char)loop1,locpal[loop1][0],locpal[loop1][1],
  367.                               locpal[loop1][2]);
  368. }
  369.  
  370.  
  371. // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  372. // Procedure GrabPallette;
  373. void GrabPallette()
  374. {
  375.   int loop1;
  376.   for(loop1=0;loop1<256;loop1++)
  377.   {
  378.     GetPal((unsigned char)loop1,&Pall2[loop1][0],&Pall2[loop1][1],&Pall2[loop1][2]);
  379.   }
  380. }
  381.  
  382. // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  383. // Procedure Blackout;
  384. //  This procedure blackens the screen by setting the pallette values of
  385. //  all the colors to zero. 
  386. void Blackout()
  387. {
  388.   int loop1;
  389.   WaitRetrace();
  390.   for(loop1=0;loop1<256;loop1++)
  391.   {
  392.     Pal((unsigned char)loop1,0,0,0);
  393.   }
  394. }
  395.  
  396. // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  397. // Procedure Fadeup;
  398. // This procedure slowly fades up the new screen }
  399. void FadeUp()
  400. {
  401.   int loop1,loop2;
  402.   char Tmp[3]; // This is temporary storage for the values of a color 
  403.  
  404.   // A color value for Red, green or blue is 0 to 63, so this loop only
  405.   // need be executed a maximum of 64 times:
  406.   for(loop1=0;loop1<64;loop1++)
  407.   {
  408.     WaitRetrace();
  409.     for(loop2=0;loop2<256;loop2++)
  410.     {
  411.       GetPal((unsigned char)loop2,&Tmp[0],&Tmp[1],&Tmp[2]);
  412.       // If the Red, Green or Blue values of color loop2 are less then they
  413.       // should be, increase them by one: 
  414.       if(Tmp[0]<Pall2[loop2][0]) Tmp[0]++;
  415.       if(Tmp[1]<Pall2[loop2][1]) Tmp[1]++;
  416.       if(Tmp[2]<Pall2[loop2][2]) Tmp[2]++;
  417.       // Set the new, altered pallette color: 
  418.       Pal((unsigned char)loop2,Tmp[0],Tmp[1],Tmp[2]);
  419.     }
  420.   }
  421. }
  422.  
  423. // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  424. // Procedure FadeDown;
  425. // This procedure fades the screen out to black. }
  426. void FadeDown()
  427. {
  428.   int loop1,loop2;
  429.   char Tmp[3]; // This is temporary storage for the values of a color 
  430.  
  431.   // A color value for Red, green or blue is 0 to 63, so this loop only
  432.   // need be executed a maximum of 64 times:
  433.   for(loop1=0;loop1<64;loop1++)
  434.   {
  435.     WaitRetrace();
  436.     for(loop2=0;loop2<256;loop2++)
  437.     {
  438.       GetPal((unsigned char)loop2,&Tmp[0],&Tmp[1],&Tmp[2]);
  439.       // If the Red, Green or Blue values of color loop2 are not yet zero,
  440.       // then, decrease them by one. }
  441.       if(Tmp[0]>0) Tmp[0]--;
  442.       if(Tmp[1]>0) Tmp[1]--;
  443.       if(Tmp[2]>0) Tmp[2]--;
  444.       // Set the new, altered pallette color: 
  445.       Pal((unsigned char)loop2,Tmp[0],Tmp[1],Tmp[2]);
  446.     }
  447.   }
  448. }
  449.  
  450. // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  451. // Procedure RestorePallette;
  452. // This procedure restores the origional pallette 
  453. void RestorePallette()
  454. {
  455.   int loop1;
  456.   WaitRetrace();
  457.   for(loop1=0;loop1<256;loop1++)
  458.     Pal ((unsigned char)loop1,Pall2[loop1][0],Pall2[loop1][1],Pall2[loop1][2]);
  459. }
  460.  
  461. ///////////////////////////////////////////////////////////////////////////////
  462.  
  463. // {DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  464. // Procedure Cls (Col : Byte; Where:Word);
  465. // This clears the screen to the specified color, on the VGA or on the
  466. // virtual screen 
  467. // Argument Where will be either VGA or Vaddr: the SEG of the Screen Pointer.
  468. void Cls(char Color, int Where)
  469. {
  470.   unsigned char far* ScreenPtr;
  471.   ScreenPtr=MK_FP(Where,0x0);
  472.   _fmemset(ScreenPtr,Color,(unsigned int)64000);
  473. }
  474.  
  475. // {DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  476. // Procedure Flip;
  477. // { This flips the virtual screen to the VGA screen. }
  478. void Flip()
  479. {
  480.   unsigned char far* ScreenPtr;
  481.   ScreenPtr=MK_FP(VGA,0x0);
  482.   _fmemmove(ScreenPtr,VirtPtr,(unsigned int)64000);
  483. }
  484.  
  485. // {DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  486. // procedure flip(source,dest:Word);
  487. //   { This copies the entire screen at "source" to destination }
  488. void Flip2(int Source, int Dest)
  489. {
  490.   _asm
  491.   {
  492.     push    ds
  493.     mov     ax, Dest
  494.     mov     es, ax
  495.     mov     ax, Source
  496.     mov     ds, ax
  497.     xor     si, si
  498.     xor     di, di
  499.     mov     cx, 32000
  500.     rep     movsw
  501.     pop     ds
  502.   }
  503. }
  504.  
  505. //////////////////////////////////////////////////////////////
  506. // Initializes the random number generator with a new seed
  507. // based on the system time
  508. void randomize()
  509. {
  510.   srand((unsigned)time(NULL));
  511. }
  512.  
  513. //////////////////////////////////////////////////////////////
  514. // returns a value from 0 to x-1.
  515. // RAND_MX1 is RAND_MAX + 1 to insure that the boundary
  516. // value of x is never attained.
  517. int random(int x)
  518. {
  519.   return (int)((long)(rand()*(long)x)/(long)RAND_MX1);
  520. }
  521.  
  522. // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
  523. // Function rad (theta : real) : real;
  524. // This calculates the degrees of an angle
  525. //   rad := theta * pi / 180
  526. float rad(float theta)
  527. {
  528.   return theta*PI/(float)180.0;
  529. }
  530.  
  531. int round(float x)
  532. {
  533.   if(x>=0)
  534.     return (int)(x+0.5);
  535.   else
  536.     return (int)(x-0.5);
  537. }
  538.  
  539. ////////////////  SetUpVirtual /////////////////////////
  540. // Sets up pointers to 2 virtual screens
  541.  
  542. void SetUpVirtual()
  543. {
  544.   VirtPtr=&Virtual[0];
  545.   Vaddr = FP_SEG(VirtPtr);
  546.   VirtPtr2=&Virtual2[0];
  547.   Vaddr2 = FP_SEG(VirtPtr2);
  548. }
  549.  
  550. //{DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  551. //Procedure Hline (x1,x2,y:word;col:byte;where:word); assembler;
  552. //  { This draws a horizontal line from x1 to x2 on line y in color col }
  553. void Hline(int x1, int x2, int y, char col, int where)
  554. {
  555.  _asm
  556.  {
  557.   mov   ax,where
  558.   mov   es,ax
  559.   mov   ax,y
  560.   mov   di,ax
  561.   shl   ax,8
  562.   shl   di,6
  563.   add   di,ax
  564.   add   di,x1
  565.  
  566.   mov   al,col
  567.   mov   ah,al
  568.   mov   cx,x2
  569.   sub   cx,x1
  570.   shr   cx,1
  571.   jnc   lstart
  572.   stosb
  573. lstart :
  574.   rep   stosw
  575.  }
  576. }
  577.  
  578. // {DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  579. // Procedure Putpixel (X,Y : Integer; Col : Byte; where:word);
  580. // This puts a pixel on the screen by writing directly to memory. }
  581. // Assembly version
  582. void PutPixel2(int x, int y, char col, int where)
  583. {
  584.   _asm
  585.   {
  586.     mov     ax,where
  587.     mov     es,ax
  588.     mov     bx,x
  589.     mov     dx,y
  590.     mov     di,bx
  591.     mov     bx, dx   //               {; bx = dx}
  592.     shl     dx, 8
  593.     shl     bx, 6
  594.     add     dx, bx   //               {; dx = dx + bx (ie y*320)}
  595.     add     di, dx   //               {; finalise location}
  596.     mov     al, col
  597.     stosb
  598.   }
  599. }    
  600.  
  601. // {DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  602. // Function Getpixel (X,Y : Integer; where:word):byte; assembler;
  603. // { This gets a pixel from the screen by reading directly from memory. }
  604. char GetPixel(int x, int y, int where)
  605. {
  606.   _asm
  607.   {
  608.   mov     ax,where
  609.   mov     es,ax
  610.   mov     bx,x
  611.   mov     dx,y
  612.   mov     di,bx
  613.   mov     bx, dx                  ; bx = dx}
  614.   shl     dx, 8
  615.   shl     bx, 6
  616.   add     dx, bx                  ; dx = dx + bx (ie y*320)}
  617.   add     di, dx                  ; finalise location}
  618.   mov     al, es:[di]
  619.   }
  620. }  
  621. // This generates warning of no return value, but
  622. // this is OK; value is returned in al. See pg. 279 "C For Yourself",
  623. // Microsoft Press.
  624.  
  625. // {DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  626. // Procedure LoadCEL (FileName :  string; ScrPtr : pointer);
  627. //  { This loads the cel 'filename' into the pointer scrptr }
  628. void LoadCEL(char* FileName, char far* ScrPtr)
  629. {
  630.   FILE* fptr;
  631.   char far* TmpPtr;
  632.   
  633.   TmpPtr=ScrPtr;  // Do this so ScrPtr doesn't get incremented.
  634.   if((fptr=fopen(FileName,"rb"))==NULL)
  635.   {                                            
  636.     SetText();
  637.     printf("Error opening file %s\n",FileName);
  638.     exit(1);
  639.   }
  640.   fseek(fptr,(long)800,SEEK_SET);  //offset 800 from beginning of file.
  641.   fread(TmpPtr,sizeof(char),(unsigned)64000,fptr);
  642.   fclose(fptr);
  643. }  
  644.  
  645. void delay(int wait)
  646. {
  647.   long goal;
  648.   goal=(long)wait + clock();
  649.   while(goal>clock());
  650. }
  651.  
  652. // {DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  653. // Procedure InitChain4; ASSEMBLER;
  654. //   {  This procedure gets you into Chain 4 mode }
  655. //   Also see listing 10.1, pg. 206 of Power Graphics Programming, Abrash
  656. void InitChain4(int ScrSize)
  657. {
  658.  _asm 
  659.  {
  660.     mov    ax, 13h
  661.     int    10h       ;  { Get into MCGA Mode }
  662.  
  663.     mov    dx, 3c4h  ;  { Port 3c4h = Sequencer Address Register }
  664.     mov    al, 4     ;  { Index 4 = memory mode }
  665.     out    dx, al
  666.     inc    dx        ;  { Port 3c5h ... here we set the mem mode }
  667.     in     al, dx
  668.     and    al, not 08h ; turn off bit 3, the C4 bit, see pg 357 Ferraro.
  669.     or     al, 04h     ; turn on bit 2, the O/E bit
  670.     out    dx, al
  671.     mov    dx, 3ceh  ; Port 3ceh = Graphics Address Register
  672.     mov    al, 5     ; Index 5 = Mode
  673.     out    dx, al
  674.     inc    dx
  675.     in     al, dx
  676.     and    al, not 10h ; turn off bit 4, the O/E bit
  677.     out    dx, al
  678.     dec    dx
  679.     mov    al, 6     ; Index 6 = Miscellaneous Register
  680.     out    dx, al
  681.     inc    dx
  682.     in     al, dx
  683.     and    al, not 02h  ; Turn of bit 1, chain odd/even
  684.     out    dx, al
  685.     mov    dx, 3c4h  ; Sequencer Address Register
  686.     mov    ax, (0fh shl 8) + 2 ; write 0fh to register: enable all 4 planes
  687.     out    dx, ax
  688.     mov    ax, 0a000h
  689.     mov    es, ax
  690.     sub    di, di
  691.     mov    ax, 0000h ;  Store 0000h to es:di, 32K times:
  692.     mov    cx, 32768 ;  8000h=32K words = 64K bytes
  693.     cld
  694.     rep    stosw      ;     { Clear garbage off the screen ... }
  695.  
  696.     mov    dx, 3d4h
  697.     mov    al, 14h  ; underline register
  698.     out    dx, al
  699.     inc    dx
  700.     in     al, dx
  701.     and    al, not 40h ; Turn off double word addressing, see pg 380 Ferraro
  702.     out    dx, al
  703.     dec    dx
  704.     mov    al, 17h  ; mode control register
  705.     out    dx, al
  706.     inc    dx
  707.     in     al, dx
  708.     or     al, 40h  ; byte mode
  709.     out    dx, al
  710.  
  711.     mov    dx, 3d4h
  712.     mov    al, 13h    ;   Offset register, = logical display width
  713.     out    dx, al
  714.     inc    dx
  715.     mov    ax, ScrSize   ;    Size * 8 = Pixels across. Only 320 are visible
  716.     out    dx, al        ;    Note that size is a keyword in MASM!
  717.   }
  718. }
  719.  
  720.  
  721. // {DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  722. // Procedure C4PutPixel(X,Y : Word; Col : Byte); ASSEMBLER;
  723. //   { This puts a pixel on the chain 4 screen }
  724. void C4PutPixel(int x, int y, char col, int ScrSize)
  725. {
  726.   _asm 
  727.   {
  728.     mov    ax,y
  729.     xor    bx,bx
  730.     mov    bx,ScrSize
  731.     imul   bx
  732.     shl    ax,1
  733.     mov    bx,ax
  734.     mov    ax, x
  735.     mov    cx, ax
  736.     shr    ax, 2
  737.     add    bx, ax
  738.     and    cx, 00000011b
  739.     mov    ah, 1
  740.     shl    ah, cl
  741.     mov    dx, 3c4h        ;         { Sequencer Register    }
  742.     mov    al, 2           ;         { Map Mask Index        }
  743.     out    dx, ax
  744.  
  745.     mov    ax, 0a000h
  746.     mov    es, ax
  747.     mov    al, col
  748.     mov    es: [bx], al
  749.   }
  750. }
  751.  
  752. // {DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  753. // Procedure Plane(Which : Byte); ASSEMBLER;
  754. //   { This sets the plane to write to in Chain 4}
  755. void Plane(char Which)
  756. {
  757.  _asm
  758.  {
  759.    mov     al, 2h
  760.    mov     ah, 1
  761.    mov     cl, Which
  762.    shl     ah, cl
  763.    mov     dx, 3c4h     ;            { Sequencer Register    }
  764.    out     dx, ax
  765.  }
  766. }
  767.  
  768.  
  769. // {DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD}
  770. // procedure moveto(x, y : word);
  771. //   { This moves to position x*4,y on a chain 4 screen }
  772. void moveto(int x, int y, int Size)
  773. {
  774.   int o;
  775.   o=y*Size*2+x;
  776.   _asm
  777.   {
  778.     mov    bx, o
  779.     mov    ah, bh
  780.     mov    al, 0ch
  781.  
  782.     mov    dx, 3d4h
  783.     out    dx, ax
  784.  
  785.     mov    ah, bl
  786.     mov    al, 0dh
  787.     mov    dx, 3d4h
  788.     out    dx, ax
  789.   }
  790. }
  791.  
  792.